Skip to content

⚡️ Speed up function post_process_validation by 55% #59

New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Jump to bottom
Open
wants to merge 1 commit into
base: main
Choose a base branch
from
Open

⚡️ Speed up function post_process_validation by 55% #59

wants to merge 1 commit into from

Conversation

@codeflash-ai
Copy link

@codeflash-ai codeflash-ai bot commented Oct 22, 2025

📄 55% (0.55x) speedup for post_process_validation in guardrails/validator_service/__init__.py

⏱️ Runtime : 14.3 milliseconds → 9.23 milliseconds (best of 61 runs)

📝 Explanation and details

The optimization achieves a 55% speedup by eliminating unnecessary object allocations and improving type checking efficiency in the validation pipeline.

Key Optimizations:

  1. Lazy allocation in apply_refrain: The original code always created a default refrain_value = {} upfront, then conditionally reassigned it. The optimized version only creates the appropriate empty value ("", [], or {}) when a refrain is actually detected, avoiding wasteful allocations in the common case where no refrain exists.

  2. Faster type checking in apply_filters: Changed isinstance(value, List) and isinstance(value, Dict) to use concrete types list and dict instead of abstract base classes. This eliminates the overhead of checking against ABC inheritance chains, making type checks ~45% faster for built-in collection types.

Performance Impact by Test Case:

  • Small structures (basic tests): 15-35% faster due to reduced type checking overhead
  • Large collections (1000+ elements): 127-147% faster where the type checking savings compound across recursive calls
  • Nested structures: 20-40% faster as both optimizations stack through recursive traversal

The optimizations are particularly effective for workloads with large nested data structures containing many lists/dicts, where the cumulative effect of faster type checks and avoided allocations provides substantial performance gains while maintaining identical functionality.

✅ Correctness verification report:

Test Status
⚙️ Existing Unit Tests 🔘 None Found
🌀 Generated Regression Tests ✅ 67 Passed
⏪ Replay Tests ✅ 127 Passed
🔎 Concolic Coverage Tests 🔘 None Found
📊 Tests Coverage 100.0%
🌀 Generated Regression Tests and Runtime 
import pytest
from guardrails.validator_service.__init__ import post_process_validation

# Mocks and minimal stubs for dependencies

class OutputTypes:
    STRING = "string"
    LIST = "list"
    DICT = "dict"

class Refrain:
    pass

class Filter:
    pass

class DummyIteration:
    def __init__(self, validator_logs):
        self.validator_logs = validator_logs
from guardrails.validator_service.__init__ import post_process_validation

# ---------------------- UNIT TESTS ----------------------

# 1. Basic Test Cases

def test_basic_string_no_refrain_no_filter():
    """String input, no Refrain or Filter present."""
    iteration = DummyIteration([])
    codeflash_output = post_process_validation("hello", 1, iteration, OutputTypes.STRING); result = codeflash_output # 13.6μs -> 10.8μs (26.2% faster)

def test_basic_list_no_refrain_no_filter():
    """List input, no Refrain or Filter present."""
    iteration = DummyIteration([])
    codeflash_output = post_process_validation([1, 2, 3], 1, iteration, OutputTypes.LIST); result = codeflash_output # 16.2μs -> 12.2μs (33.0% faster)

def test_basic_dict_no_refrain_no_filter():
    """Dict input, no Refrain or Filter present."""
    iteration = DummyIteration([])
    codeflash_output = post_process_validation({"a": 1, "b": 2}, 1, iteration, OutputTypes.DICT); result = codeflash_output # 16.5μs -> 12.4μs (33.2% faster)

def test_basic_string_with_filter():
    """String input, Filter present (should be removed)."""
    iteration = DummyIteration([])
    codeflash_output = post_process_validation(Filter(), 1, iteration, OutputTypes.STRING); result = codeflash_output # 13.6μs -> 10.8μs (25.7% faster)

def test_basic_list_with_filter():
    """List input with Filter element (should be removed)."""
    iteration = DummyIteration([])
    codeflash_output = post_process_validation([1, Filter(), 2], 1, iteration, OutputTypes.LIST); result = codeflash_output # 16.3μs -> 12.3μs (33.2% faster)

def test_basic_dict_with_filter():
    """Dict input with Filter value (should be removed)."""
    iteration = DummyIteration([])
    codeflash_output = post_process_validation({"a": Filter(), "b": 2}, 1, iteration, OutputTypes.DICT); result = codeflash_output # 16.3μs -> 12.4μs (31.7% faster)

# 2. Edge Test Cases

def test_refrain_top_level_string():
    """Top-level Refrain for string output."""
    iteration = DummyIteration([])
    codeflash_output = post_process_validation(Refrain(), 1, iteration, OutputTypes.STRING); result = codeflash_output # 13.4μs -> 10.9μs (23.1% faster)

def test_refrain_top_level_list():
    """Top-level Refrain for list output."""
    iteration = DummyIteration([])
    codeflash_output = post_process_validation(Refrain(), 1, iteration, OutputTypes.LIST); result = codeflash_output # 13.3μs -> 10.5μs (26.6% faster)

def test_refrain_top_level_dict():
    """Top-level Refrain for dict output."""
    iteration = DummyIteration([])
    codeflash_output = post_process_validation(Refrain(), 1, iteration, OutputTypes.DICT); result = codeflash_output # 13.5μs -> 10.6μs (27.6% faster)

def test_refrain_nested_in_list():
    """Refrain nested inside a list."""
    iteration = DummyIteration([])
    codeflash_output = post_process_validation([1, Refrain(), 2], 1, iteration, OutputTypes.LIST); result = codeflash_output # 16.6μs -> 11.8μs (40.4% faster)

def test_refrain_nested_in_dict():
    """Refrain nested inside a dict."""
    iteration = DummyIteration([])
    codeflash_output = post_process_validation({"a": 1, "b": Refrain()}, 1, iteration, OutputTypes.DICT); result = codeflash_output # 16.5μs -> 12.7μs (29.7% faster)

def test_refrain_deeply_nested():
    """Refrain deeply nested in a complex structure."""
    iteration = DummyIteration([])
    value = {"a": [1, {"b": Refrain()}], "c": 3}
    codeflash_output = post_process_validation(value, 1, iteration, OutputTypes.DICT); result = codeflash_output # 19.3μs -> 14.3μs (34.2% faster)

def test_filter_nested_in_list():
    """Filter nested inside a list."""
    iteration = DummyIteration([])
    value = [1, [2, Filter(), 3], 4]
    codeflash_output = post_process_validation(value, 1, iteration, OutputTypes.LIST); result = codeflash_output # 18.1μs -> 13.4μs (34.8% faster)

def test_filter_nested_in_dict():
    """Filter nested inside a dict."""
    iteration = DummyIteration([])
    value = {"a": {"b": Filter(), "c": 2}, "d": 3}
    codeflash_output = post_process_validation(value, 1, iteration, OutputTypes.DICT); result = codeflash_output # 18.3μs -> 13.5μs (35.2% faster)

def test_filter_and_refrain_mix():
    """Mix of Filter and Refrain in nested structure."""
    iteration = DummyIteration([])
    value = {"a": [Filter(), 1, {"b": Refrain()}], "c": 2}
    codeflash_output = post_process_validation(value, 1, iteration, OutputTypes.DICT); result = codeflash_output # 19.8μs -> 14.6μs (36.1% faster)

def test_empty_list():
    """Empty list input."""
    iteration = DummyIteration([])
    codeflash_output = post_process_validation([], 1, iteration, OutputTypes.LIST); result = codeflash_output # 13.7μs -> 10.7μs (27.8% faster)

def test_empty_dict():
    """Empty dict input."""
    iteration = DummyIteration([])
    codeflash_output = post_process_validation({}, 1, iteration, OutputTypes.DICT); result = codeflash_output # 14.8μs -> 11.3μs (30.9% faster)

def test_none_input():
    """None input should be returned as is."""
    iteration = DummyIteration([])
    codeflash_output = post_process_validation(None, 1, iteration, OutputTypes.STRING); result = codeflash_output # 13.6μs -> 10.6μs (28.3% faster)

def test_filter_only_list():
    """List with only Filter elements should return empty list."""
    iteration = DummyIteration([])
    codeflash_output = post_process_validation([Filter(), Filter()], 1, iteration, OutputTypes.LIST); result = codeflash_output # 15.7μs -> 11.6μs (35.7% faster)

def test_filter_only_dict():
    """Dict with only Filter values should return empty dict."""
    iteration = DummyIteration([])
    codeflash_output = post_process_validation({"a": Filter(), "b": Filter()}, 1, iteration, OutputTypes.DICT); result = codeflash_output # 16.4μs -> 12.2μs (35.0% faster)

def test_refrain_and_filter_deeply_nested():
    """Deeply nested structure with both Refrain and Filter."""
    iteration = DummyIteration([])
    value = {"x": [1, {"y": [Filter(), Refrain(), 3]}], "z": 4}
    codeflash_output = post_process_validation(value, 1, iteration, OutputTypes.DICT); result = codeflash_output # 20.8μs -> 15.5μs (33.7% faster)

# 3. Large Scale Test Cases

def test_large_list_no_refrain_no_filter():
    """Large list with no Refrain or Filter."""
    iteration = DummyIteration([])
    large_list = list(range(1000))
    codeflash_output = post_process_validation(large_list, 1, iteration, OutputTypes.LIST); result = codeflash_output # 556μs -> 228μs (144% faster)

def test_large_list_with_filters():
    """Large list with Filters interspersed."""
    iteration = DummyIteration([])
    large_list = [i if i % 10 != 0 else Filter() for i in range(1000)]
    expected = [i for i in range(1000) if i % 10 != 0]
    codeflash_output = post_process_validation(large_list, 1, iteration, OutputTypes.LIST); result = codeflash_output # 559μs -> 225μs (147% faster)

def test_large_dict_with_filters():
    """Large dict with Filters as values for some keys."""
    iteration = DummyIteration([])
    large_dict = {str(i): (i if i % 10 != 0 else Filter()) for i in range(1000)}
    expected = {str(i): i for i in range(1000) if i % 10 != 0}
    codeflash_output = post_process_validation(large_dict, 1, iteration, OutputTypes.DICT); result = codeflash_output # 586μs -> 253μs (131% faster)

def test_large_nested_structure_with_refrain():
    """Large nested structure with a Refrain deep inside."""
    iteration = DummyIteration([])
    # Insert a Refrain at a deep position
    value = {"outer": [i for i in range(500)] + [{"inner": [i for i in range(500)] + [Refrain()]}]}
    codeflash_output = post_process_validation(value, 1, iteration, OutputTypes.DICT); result = codeflash_output # 564μs -> 230μs (145% faster)

def test_large_nested_structure_with_filters():
    """Large nested structure with Filters scattered throughout."""
    iteration = DummyIteration([])
    value = {
        "a": [i if i % 20 != 0 else Filter() for i in range(500)],
        "b": {"x": [Filter() if i % 15 == 0 else i for i in range(500)]}
    }
    expected = {
        "a": [i for i in range(500) if i % 20 != 0],
        "b": {"x": [i for i in range(500) if i % 15 != 0]}
    }
    codeflash_output = post_process_validation(value, 1, iteration, OutputTypes.DICT); result = codeflash_output # 550μs -> 230μs (139% faster)
# codeflash_output is used to check that the output of the original code is the same as that of the optimized code.
#------------------------------------------------
import pytest
from guardrails.validator_service.__init__ import post_process_validation

# --- Mocks and minimal implementations for dependencies ---

# OutputTypes enum
class OutputTypes:
    STRING = "string"
    LIST = "list"

# Refrain and Filter marker classes
class Refrain:
    pass

class Filter:
    pass

# Minimal Iteration and ValidatorLogs for tracing
class ValidatorLogs:
    def __init__(self):
        self.registered_name = "mock_validator"
        self.value_before_validation = None
        self.validation_result = type("Result", (), {"outcome": "pass"})()
        self.value_after_validation = None
        self.start_time = None
        self.end_time = None
        self.instance_id = "id"

class Iteration:
    def __init__(self, logs=None):
        if logs is None:
            logs = [ValidatorLogs()]
        self.validator_logs = logs
from guardrails.validator_service.__init__ import post_process_validation

# --- Unit Tests ---

# 1. Basic Test Cases
def test_string_no_refrain_no_filter():
    # Simple string, no Refrain or Filter
    codeflash_output = post_process_validation("hello", 1, Iteration(), OutputTypes.STRING); result = codeflash_output # 23.3μs -> 19.9μs (17.1% faster)

def test_list_no_refrain_no_filter():
    # Simple list, no Refrain or Filter
    codeflash_output = post_process_validation([1, 2, 3], 1, Iteration(), OutputTypes.LIST); result = codeflash_output # 25.2μs -> 20.5μs (23.0% faster)

def test_dict_no_refrain_no_filter():
    # Simple dict, no Refrain or Filter
    codeflash_output = post_process_validation({'a': 1, 'b': 2}, 1, Iteration(), OutputTypes.LIST); result = codeflash_output # 25.1μs -> 20.2μs (24.1% faster)

def test_string_with_refrain():
    # String replaced by "" if Refrain present
    codeflash_output = post_process_validation(Refrain(), 1, Iteration(), OutputTypes.STRING); result = codeflash_output # 22.0μs -> 18.8μs (17.1% faster)

def test_list_with_refrain():
    # List replaced by [] if Refrain present
    codeflash_output = post_process_validation([Refrain(), 1], 1, Iteration(), OutputTypes.LIST); result = codeflash_output # 24.2μs -> 20.0μs (20.8% faster)

def test_dict_with_refrain():
    # Dict replaced by [] (since output_type=LIST) if Refrain present anywhere
    codeflash_output = post_process_validation({'a': Refrain(), 'b': 2}, 1, Iteration(), OutputTypes.LIST); result = codeflash_output # 24.8μs -> 20.3μs (22.3% faster)

def test_dict_with_refrain_string():
    # Dict replaced by "" if output_type=STRING
    codeflash_output = post_process_validation({'a': Refrain(), 'b': 2}, 1, Iteration(), OutputTypes.STRING); result = codeflash_output # 24.5μs -> 20.4μs (20.0% faster)

def test_list_with_filter():
    # Filter removes elements from list
    codeflash_output = post_process_validation([1, Filter(), 3], 1, Iteration(), OutputTypes.LIST); result = codeflash_output # 24.9μs -> 20.1μs (23.9% faster)

def test_dict_with_filter():
    # Filter removes keys from dict
    codeflash_output = post_process_validation({'a': 1, 'b': Filter(), 'c': 3}, 1, Iteration(), OutputTypes.LIST); result = codeflash_output # 25.0μs -> 20.5μs (22.0% faster)

def test_nested_list_with_filter():
    # Nested list with Filter
    codeflash_output = post_process_validation([1, [Filter(), 2], 3], 1, Iteration(), OutputTypes.LIST); result = codeflash_output # 25.8μs -> 20.5μs (26.1% faster)

def test_nested_dict_with_filter():
    # Nested dict with Filter
    data = {'a': {'x': Filter(), 'y': 2}, 'b': 3}
    codeflash_output = post_process_validation(data, 1, Iteration(), OutputTypes.LIST); result = codeflash_output # 25.5μs -> 21.2μs (20.6% faster)

def test_list_with_refrain_and_filter():
    # Refrain takes precedence, returns [] even if Filter present
    codeflash_output = post_process_validation([Filter(), Refrain(), 2], 1, Iteration(), OutputTypes.LIST); result = codeflash_output # 24.5μs -> 20.4μs (20.0% faster)

def test_dict_with_refrain_and_filter():
    # Refrain takes precedence, returns [] even if Filter present
    codeflash_output = post_process_validation({'a': Filter(), 'b': Refrain(), 'c': 3}, 1, Iteration(), OutputTypes.LIST); result = codeflash_output # 25.4μs -> 20.9μs (21.5% faster)

def test_dict_with_refrain_and_filter_string():
    # Refrain takes precedence, returns "" if output_type=STRING
    codeflash_output = post_process_validation({'a': Filter(), 'b': Refrain(), 'c': 3}, 1, Iteration(), OutputTypes.STRING); result = codeflash_output # 25.2μs -> 20.6μs (22.1% faster)

def test_empty_list():
    # Empty list should remain unchanged
    codeflash_output = post_process_validation([], 1, Iteration(), OutputTypes.LIST); result = codeflash_output # 21.4μs -> 18.3μs (16.8% faster)

def test_empty_dict():
    # Empty dict should remain unchanged
    codeflash_output = post_process_validation({}, 1, Iteration(), OutputTypes.LIST); result = codeflash_output # 22.5μs -> 19.0μs (18.1% faster)

def test_empty_string():
    # Empty string should remain unchanged
    codeflash_output = post_process_validation("", 1, Iteration(), OutputTypes.STRING); result = codeflash_output # 21.7μs -> 18.3μs (18.6% faster)

# 2. Edge Test Cases

def test_all_filter_list():
    # All elements are Filter, should return []
    codeflash_output = post_process_validation([Filter(), Filter()], 1, Iteration(), OutputTypes.LIST); result = codeflash_output # 23.8μs -> 19.6μs (21.6% faster)

def test_all_filter_dict():
    # All keys are Filter, should return {}
    codeflash_output = post_process_validation({'a': Filter(), 'b': Filter()}, 1, Iteration(), OutputTypes.LIST); result = codeflash_output # 24.5μs -> 19.9μs (22.9% faster)

def test_nested_refrain_in_list():
    # Deeply nested Refrain in list
    codeflash_output = post_process_validation([1, [2, [Refrain()]]], 1, Iteration(), OutputTypes.LIST); result = codeflash_output # 25.8μs -> 21.0μs (22.9% faster)

def test_nested_refrain_in_dict():
    # Deeply nested Refrain in dict
    data = {'a': {'b': {'c': Refrain()}}}
    codeflash_output = post_process_validation(data, 1, Iteration(), OutputTypes.LIST); result = codeflash_output # 25.1μs -> 20.8μs (20.7% faster)

def test_nested_mix_refrain_and_filter():
    # Deeply nested mix: Refrain takes precedence
    data = {'a': [1, {'b': Filter()}, Refrain()]}
    codeflash_output = post_process_validation(data, 1, Iteration(), OutputTypes.LIST); result = codeflash_output # 26.8μs -> 22.0μs (21.6% faster)

def test_non_list_dict_string_with_filter():
    # Scalar value with Filter should remain unchanged
    codeflash_output = post_process_validation(42, 1, Iteration(), OutputTypes.LIST); result = codeflash_output # 21.9μs -> 18.9μs (16.2% faster)

def test_non_list_dict_string_with_refrain():
    # Scalar value with Refrain should be replaced appropriately
    codeflash_output = post_process_validation(Refrain(), 1, Iteration(), OutputTypes.LIST); result = codeflash_output # 21.8μs -> 18.8μs (15.9% faster)

def test_list_of_dicts_with_filter():
    # List of dicts, some keys filtered
    data = [{'a': 1, 'b': Filter()}, {'c': 3, 'd': 4}]
    codeflash_output = post_process_validation(data, 1, Iteration(), OutputTypes.LIST); result = codeflash_output # 27.6μs -> 22.0μs (25.4% faster)

def test_dict_of_lists_with_filter():
    # Dict of lists, some elements filtered
    data = {'x': [1, Filter(), 3], 'y': [Filter(), 2]}
    codeflash_output = post_process_validation(data, 1, Iteration(), OutputTypes.LIST); result = codeflash_output # 27.7μs -> 21.8μs (27.1% faster)

def test_dict_of_lists_with_refrain():
    # Dict of lists, Refrain present somewhere
    data = {'x': [1, Refrain(), 3], 'y': [2]}
    codeflash_output = post_process_validation(data, 1, Iteration(), OutputTypes.LIST); result = codeflash_output # 27.2μs -> 21.8μs (24.4% faster)

def test_list_of_dicts_with_refrain():
    # List of dicts, Refrain present somewhere
    data = [{'a': 1}, {'b': Refrain()}]
    codeflash_output = post_process_validation(data, 1, Iteration(), OutputTypes.LIST); result = codeflash_output # 26.3μs -> 21.2μs (24.2% faster)

def test_list_of_lists_with_filter_and_refrain():
    # List of lists, Refrain present, should return []
    data = [[1, Filter()], [Refrain(), 2]]
    codeflash_output = post_process_validation(data, 1, Iteration(), OutputTypes.LIST); result = codeflash_output # 26.0μs -> 21.3μs (22.3% faster)

def test_list_of_lists_with_filter_only():
    # List of lists, only Filter present, should remove them
    data = [[1, Filter()], [2, 3]]
    codeflash_output = post_process_validation(data, 1, Iteration(), OutputTypes.LIST); result = codeflash_output # 26.2μs -> 21.4μs (22.4% faster)

def test_dict_with_non_string_keys():
    # Dict with non-string keys, should work
    data = {1: "a", 2: Filter(), 3: "c"}
    codeflash_output = post_process_validation(data, 1, Iteration(), OutputTypes.LIST); result = codeflash_output # 25.1μs -> 20.2μs (23.9% faster)

def test_dict_with_none_value():
    # Dict with None value, should not be filtered
    data = {'a': None, 'b': 1}
    codeflash_output = post_process_validation(data, 1, Iteration(), OutputTypes.LIST); result = codeflash_output # 24.7μs -> 20.1μs (23.2% faster)

def test_list_with_none_value():
    # List with None value, should not be filtered
    data = [None, 1, 2]
    codeflash_output = post_process_validation(data, 1, Iteration(), OutputTypes.LIST); result = codeflash_output # 24.5μs -> 19.9μs (23.2% faster)

# 3. Large Scale Test Cases

def test_large_list_no_refrain_no_filter():
    # Large list, no Refrain or Filter
    data = list(range(1000))
    codeflash_output = post_process_validation(data, 1, Iteration(), OutputTypes.LIST); result = codeflash_output # 569μs -> 233μs (144% faster)

def test_large_list_with_filter():
    # Large list, every 10th element is Filter
    data = [Filter() if i % 10 == 0 else i for i in range(1000)]
    expected = [i for i in range(1000) if i % 10 != 0]
    codeflash_output = post_process_validation(data, 1, Iteration(), OutputTypes.LIST); result = codeflash_output # 566μs -> 235μs (140% faster)

def test_large_list_with_refrain():
    # Large list, Refrain at the end
    data = list(range(999)) + [Refrain()]
    codeflash_output = post_process_validation(data, 1, Iteration(), OutputTypes.LIST); result = codeflash_output # 566μs -> 236μs (139% faster)

def test_large_dict_no_refrain_no_filter():
    # Large dict, no Refrain or Filter
    data = {str(i): i for i in range(1000)}
    codeflash_output = post_process_validation(data, 1, Iteration(), OutputTypes.LIST); result = codeflash_output # 590μs -> 259μs (127% faster)

def test_large_dict_with_filter():
    # Large dict, every 10th key is Filter
    data = {str(i): Filter() if i % 10 == 0 else i for i in range(1000)}
    expected = {str(i): i for i in range(1000) if i % 10 != 0}
    codeflash_output = post_process_validation(data, 1, Iteration(), OutputTypes.LIST); result = codeflash_output # 593μs -> 259μs (128% faster)

def test_large_dict_with_refrain():
    # Large dict, Refrain in one key
    data = {str(i): i for i in range(999)}
    data['refrain'] = Refrain()
    codeflash_output = post_process_validation(data, 1, Iteration(), OutputTypes.LIST); result = codeflash_output # 591μs -> 260μs (127% faster)

def test_large_nested_structure_with_filter_and_refrain():
    # Large nested structure, Refrain deep inside
    data = {
        "outer": [
            {"inner": [i for i in range(100)]},
            {"inner": [Filter() if i % 7 == 0 else i for i in range(100)]},
            {"inner": [Refrain()]}
        ]
    }
    codeflash_output = post_process_validation(data, 1, Iteration(), OutputTypes.LIST); result = codeflash_output # 140μs -> 68.1μs (106% faster)

def test_large_nested_structure_with_filter_only():
    # Large nested structure, only Filter
    data = {
        "outer": [
            {"inner": [i for i in range(100)]},
            {"inner": [Filter() if i % 7 == 0 else i for i in range(100)]}
        ]
    }
    expected = {
        "outer": [
            {"inner": [i for i in range(100)]},
            {"inner": [i for i in range(100) if i % 7 != 0]}
        ]
    }
    codeflash_output = post_process_validation(data, 1, Iteration(), OutputTypes.LIST); result = codeflash_output # 137μs -> 66.5μs (107% faster)
# codeflash_output is used to check that the output of the original code is the same as that of the optimized code.
⏪ Replay Tests and Runtime
Test File::Test Function Original ⏱️ Optimized ⏱️ Speedup
test_pytest_testsunit_teststest_guard_log_py_testsintegration_teststest_guard_py_testsunit_testsvalidator__replay_test_0.py::test_guardrails_validator_service___init___post_process_validation 6.58ms 5.51ms 19.4%✅

To edit these changes git checkout codeflash/optimize-post_process_validation-mh1riwy0 and push.

Codeflash

@codeflash-ai
Optimize post_process_validation
2bccda3 
The optimization achieves a **55% speedup** by eliminating unnecessary object allocations and improving type checking efficiency in the validation pipeline.

**Key Optimizations:**

1. **Lazy allocation in `apply_refrain`**: The original code always created a default `refrain_value = {}` upfront, then conditionally reassigned it. The optimized version only creates the appropriate empty value (`""`, `[]`, or `{}`) when a refrain is actually detected, avoiding wasteful allocations in the common case where no refrain exists.

2. **Faster type checking in `apply_filters`**: Changed `isinstance(value, List)` and `isinstance(value, Dict)` to use concrete types `list` and `dict` instead of abstract base classes. This eliminates the overhead of checking against ABC inheritance chains, making type checks ~45% faster for built-in collection types.

**Performance Impact by Test Case:**
- **Small structures** (basic tests): 15-35% faster due to reduced type checking overhead
- **Large collections** (1000+ elements): 127-147% faster where the type checking savings compound across recursive calls
- **Nested structures**: 20-40% faster as both optimizations stack through recursive traversal

The optimizations are particularly effective for workloads with large nested data structures containing many lists/dicts, where the cumulative effect of faster type checks and avoided allocations provides substantial performance gains while maintaining identical functionality.
@codeflash-ai codeflash-ai bot requested a review from mashraf-222 October 22, 2025 09:00
@codeflash-ai codeflash-ai bot added the ⚡️ codeflash Optimization PR opened by Codeflash AI label Oct 22, 2025
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment

Reviewers

@mashraf-222 mashraf-222 Awaiting requested review from mashraf-222

Assignees

No one assigned

Labels

⚡️ codeflash Optimization PR opened by Codeflash AI

Projects

None yet

Milestone

No milestone

Development

Successfully merging this pull request may close these issues.

0 participants